#!/usr/bin/env node

/**
 * 自动化国际化脚本
 * 功能：
 * 1. 扫描项目中的中文文本
 * 2. 自动生成国际化key
 * 3. 自动翻译为英文
 * 4. 替换原文件中的中文为i18n key
 * 5. 更新语言包文件
 */

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const translate = require('google-translate-api-x');

class I18nAutoTool {
  constructor() {
    this.projectRoot = path.resolve(__dirname, '../');
    this.i18nPath = path.join(this.projectRoot, 'src/i18n/config');
    this.srcPath = path.join(this.projectRoot, 'src');
    
    // 中文正则表达式
    this.chineseRegex = /[\u4e00-\u9fa5]+/g;
    
    // 需要扫描的文件扩展名
    this.fileExtensions = ['.vue', '.js', '.ts'];
    
    // 排除的目录
    this.excludeDirs = ['node_modules', '.git', 'dist', 'build', 'i18n', 'uni_modules'];
    
    // 已有的中文文本映射
    this.existingChineseKeys = new Map();
    this.existingEnglishKeys = new Map();
    
    // 新发现的中文文本
    this.newChineseTexts = new Map();
    
    // 中文文本到key的映射
    this.chineseToKeyMap = new Map();
    
    console.log('🚀 自动化国际化工具启动');
    console.log(`📁 项目根目录: ${this.projectRoot}`);
    console.log(`🌐 国际化目录: ${this.i18nPath}`);
  }

  /**
   * 加载现有的语言包
   */
  loadExistingLanguagePacks() {
    console.log('\n📚 加载现有语言包...');
    
    try {
      // 加载中文语言包
      const zhPath = path.join(this.i18nPath, 'zh');
      this.loadLanguageFiles(zhPath, this.existingChineseKeys);
      
      // 加载英文语言包
      const enPath = path.join(this.i18nPath, 'en');
      this.loadLanguageFiles(enPath, this.existingEnglishKeys);
      
      console.log(`✅ 已加载 ${this.existingChineseKeys.size} 个中文键值对`);
      console.log(`✅ 已加载 ${this.existingEnglishKeys.size} 个英文键值对`);
    } catch (error) {
      console.warn('⚠️ 加载语言包时出错:', error.message);
    }
  }

  /**
   * 递归加载语言文件
   */
  loadLanguageFiles(dirPath, keyMap) {
    if (!fs.existsSync(dirPath)) return;
    
    const files = fs.readdirSync(dirPath);
    
    files.forEach(file => {
      const filePath = path.join(dirPath, file);
      const stat = fs.statSync(filePath);
      
      if (stat.isDirectory()) {
        this.loadLanguageFiles(filePath, keyMap);
      } else if (file.endsWith('.js')) {
        try {
          // 动态加载JS模块
          delete require.cache[require.resolve(filePath)];
          const content = require(filePath);
          this.flattenObject(content.default || content, keyMap);
        } catch (error) {
          console.warn(`⚠️ 无法加载 ${filePath}:`, error.message);
        }
      }
    });
  }

  /**
   * 扁平化对象，提取所有键值对
   */
  flattenObject(obj, targetMap, prefix = '') {
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        const newKey = prefix ? `${prefix}.${key}` : key;
        
        if (typeof obj[key] === 'object' && obj[key] !== null) {
          this.flattenObject(obj[key], targetMap, newKey);
        } else if (typeof obj[key] === 'string') {
          targetMap.set(obj[key], newKey);
        }
      }
    }
  }

  /**
   * 扫描项目文件中的中文文本
   */
  scanChineseTexts() {
    console.log('\n🔍 扫描项目中文文本...');
    
    this.scanDirectory(this.srcPath);
    
    console.log(`🎯 发现 ${this.newChineseTexts.size} 个新的中文文本`);
    
    // 显示部分示例
    let count = 0;
    for (const [text, files] of this.newChineseTexts) {
      if (count < 5) {
        console.log(`   "${text}" (出现在 ${files.size} 个文件中)`);
        count++;
      }
    }
    if (this.newChineseTexts.size > 5) {
      console.log(`   ... 还有 ${this.newChineseTexts.size - 5} 个`);
    }
  }

  /**
   * 递归扫描目录
   */
  scanDirectory(dirPath) {
    const files = fs.readdirSync(dirPath);
    
    files.forEach(file => {
      const filePath = path.join(dirPath, file);
      const stat = fs.statSync(filePath);
      
      if (stat.isDirectory()) {
        // 跳过排除的目录
        if (!this.excludeDirs.includes(file)) {
          this.scanDirectory(filePath);
        }
      } else {
        // 检查文件扩展名
        const ext = path.extname(file);
        if (this.fileExtensions.includes(ext)) {
          this.scanFile(filePath);
        }
      }
    });
  }

  /**
   * 扫描单个文件，跳过注释和不需要国际化的内容
   */
  scanFile(filePath) {
    try {
      const content = fs.readFileSync(filePath, 'utf8');
      
      // 按行分析，跳过注释和不需要国际化的内容
      const lines = content.split('\n');
      const validChineseTexts = new Set();
      
      for (let i = 0; i < lines.length; i++) {
        const line = lines[i].trim();
        
        // 跳过空行
        if (!line) continue;
        
        // 跳过注释行
        if (this.isCommentLine(line)) continue;
        
        // 跳过 console 语句
        if (this.isConsoleStatement(line)) continue;
        
        // 查找当前行中的中文文本
        const chineseMatches = line.match(this.chineseRegex);
        if (chineseMatches) {
          chineseMatches.forEach(match => {
            // 检查中文文本的上下文，确定是否需要国际化
            if (this.shouldTranslate(line, match)) {
              validChineseTexts.add(match);
            }
          });
        }
      }
      
      // 将有效的中文文本添加到结果中
      validChineseTexts.forEach(match => {
        if (!this.existingChineseKeys.has(match)) {
          if (!this.newChineseTexts.has(match)) {
            this.newChineseTexts.set(match, new Set());
          }
          this.newChineseTexts.get(match).add(filePath);
        }
      });
      
    } catch (error) {
      console.warn(`⚠️ 无法读取文件 ${filePath}:`, error.message);
    }
  }

  /**
   * 判断是否为注释行
   */
  isCommentLine(line) {
    // 单行注释
    if (line.startsWith('//') || line.startsWith('*') || line.startsWith('/*')) {
      return true;
    }
    
    // HTML/Vue 注释
    if (line.startsWith('<!--') || line.includes('<!--') || line.includes('-->')) {
      return true;
    }
    
    return false;
  }

  /**
   * 判断是否为 console 语句
   */
  isConsoleStatement(line) {
    return line.includes('console.') || 
           line.includes('console[') ||
           line.includes('console.log') ||
           line.includes('console.warn') ||
           line.includes('console.error') ||
           line.includes('console.info') ||
           line.includes('console.debug');
  }

  /**
   * 判断中文文本是否需要翻译
   */
  shouldTranslate(line, chineseText) {
    // 跳过已经国际化的文本（包含 $t）
    if (line.includes('$t(') || line.includes('this.$t(')) {
      return false;
    }
    
    // 跳过 console 语句中的文本
    if (this.isConsoleStatement(line)) {
      return false;
    }
    
    // 跳过注释中的文本
    if (line.includes('//') && line.indexOf('//') < line.indexOf(chineseText)) {
      return false;
    }
    
    // 跳过 URL 和路径中的中文
    if (line.includes('http') || line.includes('www.') || line.includes('.com')) {
      return false;
    }
    
    // 跳过变量名和属性名中的中文（通常在对象定义中）
    if (line.includes(':') && line.indexOf(':') > line.indexOf(chineseText)) {
      // 这可能是对象的属性名，需要进一步判断
      const beforeColon = line.substring(0, line.indexOf(':')).trim();
      if (beforeColon.endsWith(`"${chineseText}"`) || beforeColon.endsWith(`'${chineseText}'`)) {
        return false; // 这是属性名，不需要翻译
      }
    }
    
    // 跳过 import/require 语句中的文本
    if (line.includes('import') || line.includes('require(')) {
      return false;
    }
    
    // 跳过文件扩展名和技术术语
    const technicalTerms = ['vue', 'js', 'css', 'html', 'json', 'md', 'scss', 'ts'];
    if (technicalTerms.includes(chineseText.toLowerCase())) {
      return false;
    }
    
    // 跳过单个字符（通常是标点符号或无意义的字符）
    if (chineseText.length === 1 && /[，。！？；：（）【】""''、]/.test(chineseText)) {
      return false;
    }
    
    return true;
  }

  /**
   * 基于文件路径生成国际化key
   */
  generateI18nKey(chineseText, filePaths) {
    // 获取主要文件路径（使用第一个文件路径）
    const primaryFilePath = Array.from(filePaths)[0];
    
    // 生成基于路径的key
    return this.generatePathBasedKey(chineseText, primaryFilePath);
  }

  /**
   * 基于文件路径生成key
   */
  generatePathBasedKey(chineseText, filePath) {
    // 获取相对于src目录的路径
    const relativePath = path.relative(this.srcPath, filePath);
    
    // 提取文件路径信息
    const pathParts = relativePath.split(path.sep);
    const fileName = path.basename(filePath, path.extname(filePath));
    
    // 生成路径前缀
    let pathPrefix = '';
    if (pathParts.length > 1) {
      // 使用目录结构生成前缀，如 pages/event/list -> pages_event_list
      const dirs = pathParts.slice(0, -1).filter(dir => dir !== 'src');
      if (dirs.length > 0) {
        pathPrefix = dirs.join('_') + '_';
      }
    }
    
    // 基于中文内容生成语义化key
    let semanticKey = this.generateSemanticKey(chineseText);
    
    // 组合路径前缀和语义化key
    return `${pathPrefix}${fileName}_${semanticKey}`;
  }

  /**
   * 生成语义化key
   */
  generateSemanticKey(chineseText) {
    // 常见词汇映射
    const commonWords = {
      '确认': 'confirm',
      '取消': 'cancel',
      '提交': 'submit',
      '保存': 'save',
      '删除': 'delete',
      '编辑': 'edit',
      '添加': 'add',
      '搜索': 'search',
      '登录': 'login',
      '注册': 'register',
      '退出': 'logout',
      '首页': 'home',
      '我的': 'mine',
      '设置': 'settings',
      '返回': 'back',
      '下一步': 'next',
      '上一步': 'previous',
      '完成': 'complete',
      '失败': 'failed',
      '成功': 'success',
      '错误': 'error',
      '警告': 'warning',
      '信息': 'info',
      '加载中': 'loading',
      '无数据': 'noData',
      '网络错误': 'networkError',
      '操作成功': 'operateSuccess',
      '操作失败': 'operateFailed',
      '马拉松': 'marathon',
      '比赛': 'race',
      '参赛者': 'participant',
      '成绩': 'result',
      '证书': 'certificate',
      '暂无': 'none',
      '未知': 'unknown'
    };

    // 检查是否有直接映射
    if (commonWords[chineseText]) {
      return commonWords[chineseText];
    }
    
    // 基于内容生成hash的key
    const hash = crypto.createHash('md5').update(chineseText).digest('hex').substring(0, 8);
    
    // 根据长度生成不同类型的key
    if (chineseText.length <= 2) {
      return `text_${hash}`;
    } else if (chineseText.length <= 6) {
      return `msg_${hash}`;
    } else {
      return `desc_${hash}`;
    }
  }

  /**
   * 获取支持的语言列表
   */
  getSupportedLanguages() {
    const languages = [];
    const configPath = path.join(this.i18nPath);
    
    if (fs.existsSync(configPath)) {
      const items = fs.readdirSync(configPath);
      for (const item of items) {
        const itemPath = path.join(configPath, item);
        if (fs.statSync(itemPath).isDirectory()) {
          languages.push(item);
        }
      }
    }
    
    return languages.filter(lang => lang !== 'zh'); // 排除中文，因为中文是源语言
  }

  /**
   * 使用Google Translate API翻译到指定语言
   */
  async translateToLanguage(chineseText, targetLang) {
    try {
      // 对于空文本或非常短的文本，跳过翻译
      if (!chineseText || chineseText.trim().length === 0) {
        return chineseText;
      }
      
      // 调用Google Translate API
      const result = await translate(chineseText, { 
        from: 'zh-cn', 
        to: targetLang,
        forceFrom: true // 强制指定源语言
      });
      
      return result.text;
    } catch (error) {
      console.warn(`⚠️ 翻译失败 "${chineseText}" -> ${targetLang}:`, error.message);
      
      // 翻译失败时的fallback处理
      if (targetLang === 'en') {
        return this.generateEnglishPlaceholder(chineseText);
      }
      
      return chineseText;
    }
  }

  /**
   * 生成英文占位符（作为翻译失败时的备选方案）
   */
  generateEnglishPlaceholder(chineseText) {
    const length = chineseText.length;
    
    if (length <= 2) {
      return `Text_${chineseText}`;
    } else if (length <= 6) {
      return `Message_${chineseText}`;
    } else {
      return `Description_${chineseText}`;
    }
  }

  /**
   * 简单的翻译功能（保持向后兼容）
   */
  async translateToEnglish(chineseText) {
    return await this.translateToLanguage(chineseText, 'en');
  }

  /**
   * 生成新的语言包内容（支持异步翻译）
   */
  async generateLanguagePacks() {
    console.log('\n🌐 生成新的语言包...');
    
    const supportedLanguages = this.getSupportedLanguages();
    const languageEntries = {};
    
    // 初始化各语言的条目对象
    languageEntries['zh'] = {}; // 中文（源语言）
    for (const lang of supportedLanguages) {
      languageEntries[lang] = {};
    }

    console.log(`📝 准备翻译 ${this.newChineseTexts.size} 个文本到 ${supportedLanguages.length} 种语言...`);
    
    let processedCount = 0;
    
    for (const [chineseText, filePaths] of this.newChineseTexts.entries()) {
      const key = this.generateI18nKey(chineseText, filePaths);
      
      // 确保key唯一
      let uniqueKey = key;
      let counter = 1;
      while (this.existingChineseKeys.has(uniqueKey) || languageEntries['zh'][uniqueKey]) {
        uniqueKey = `${key}_${counter}`;
        counter++;
      }
      
      // 添加中文条目
      languageEntries['zh'][uniqueKey] = chineseText;
      
      // 为每种支持的语言生成翻译
      for (const lang of supportedLanguages) {
        try {
          const translatedText = await this.translateToLanguage(chineseText, lang);
          languageEntries[lang][uniqueKey] = translatedText;
        } catch (error) {
          console.warn(`⚠️ 翻译失败: "${chineseText}" -> ${lang}`);
          languageEntries[lang][uniqueKey] = chineseText; // 使用原文作为备选
        }
      }
      
      // 更新映射表
      this.existingChineseKeys.set(uniqueKey, chineseText);
      this.chineseToKeyMap.set(chineseText, uniqueKey);
      
      processedCount++;
      if (processedCount % 10 === 0) {
        console.log(`🔄 已处理 ${processedCount}/${this.newChineseTexts.size} 个文本...`);
      }
      
      // 添加小延迟避免API限制
      await new Promise(resolve => setTimeout(resolve, 100));
    }

    console.log(`✅ 翻译完成！处理了 ${processedCount} 个文本`);
    return languageEntries;
  }

  /**
   * 更新语言包文件
   */
  updateLanguageFiles(languageEntries) {
    console.log('\n📝 更新语言包文件...');
    
    const languageComments = {
      'zh': '// 自动生成的中文语言包',
      'en': '// Auto-generated English language pack'
    };
    
    // 更新所有语言的语言包文件
    for (const [lang, entries] of Object.entries(languageEntries)) {
      const filePath = path.join(this.i18nPath, `${lang}/auto-generated.js`);
      const comment = languageComments[lang] || `// Auto-generated ${lang} language pack`;
      
      this.updateLanguageFile(filePath, entries, comment);
      
      // 同时更新对应语言的index.js文件
      this.updateIndexFile(
        path.join(this.i18nPath, `${lang}/index.js`),
        'autoGenerated'
      );
    }
  }

  /**
   * 更新单个语言包文件
   */
  updateLanguageFile(filePath, entries, comment) {
    const dir = path.dirname(filePath);
    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir, { recursive: true });
    }

    const content = `${comment}
export default ${JSON.stringify(entries, null, 2)}
`;

    fs.writeFileSync(filePath, content, 'utf8');
    console.log(`✅ 已更新 ${filePath} (${Object.keys(entries).length} 个条目)`);
  }


  /**
   * 更新单个index.js文件
   */
  updateIndexFile(filePath, importName) {
    if (!fs.existsSync(filePath)) return;
    
    let content = fs.readFileSync(filePath, 'utf8');
    
    // 检查是否已经导入了auto-generated
    if (!content.includes('auto-generated')) {
      // 添加导入
      const importLine = `import ${importName} from './auto-generated'`;
      content = content.replace(
        /(import\s+\w+\s+from\s+['"]\.\/\w+['"])/g,
        `$1\n${importLine}`
      );
      
      // 添加到导出对象
      content = content.replace(
        /export default \{([^}]+)\}/,
        `export default {\n  ...${importName},$1}`
      );
      
      fs.writeFileSync(filePath, content, 'utf8');
      console.log(`✅ 已更新 ${filePath} 以包含自动生成的语言包`);
    }
  }

  /**
   * 替换项目文件中的中文文本
   */
  replaceChineseInFiles() {
    console.log('\n🔄 替换项目文件中的中文文本...');
    
    let replacedCount = 0;
    
    for (const [chineseText, files] of this.newChineseTexts) {
      const i18nKey = this.chineseToKeyMap.get(chineseText);
      if (!i18nKey) continue;
      
      for (const filePath of files) {
        try {
          let content = fs.readFileSync(filePath, 'utf8');
          const originalContent = content;
          
          // 智能替换中文文本为i18n调用
          content = this.smartReplaceChineseText(content, chineseText, i18nKey);
          
          if (content !== originalContent) {
            fs.writeFileSync(filePath, content, 'utf8');
            replacedCount++;
          }
        } catch (error) {
          console.warn(`⚠️ 替换文件 ${filePath} 时出错:`, error.message);
        }
      }
    }
    
    console.log(`✅ 已替换 ${replacedCount} 个文件中的中文文本`);
  }

  /**
   * 智能替换中文文本，处理各种语法情况
   */
  smartReplaceChineseText(content, chineseText, i18nKey) {
    const escapedText = this.escapeRegex(chineseText);
    
    // 判断是否在Vue template中
    const isInTemplate = content.includes('<template>');
    
    // 1. 处理Vue template中的属性绑定
    if (isInTemplate) {
      // Vue template中的属性: prop="中文" -> :prop="$t('key')"
      content = content.replace(
        new RegExp(`(\\s+)(\\w+)=(['"])${escapedText}\\3`, 'g'),
        `$1:$2="$t('${i18nKey}')"`
      );
      
      // Vue template中的插值表达式: {{ 中文 }} -> {{ $t('key') }}
      content = content.replace(
        new RegExp(`\\{\\{\\s*(['"])${escapedText}\\1\\s*\\}\\}`, 'g'),
        `{{ $t('${i18nKey}') }}`
      );
      
      // Vue template中已有的this.$t替换为$t: {{ this.$t('key') }} -> {{ $t('key') }}
      content = content.replace(
        new RegExp(`\\{\\{\\s*this\\.\\$t\\((['"])[^'"]*(\\1)\\)\\s*\\}\\}`, 'g'),
        `{{ $t('${i18nKey}') }}`
      );
      
      // Vue template中属性绑定的this.$t替换为$t: :prop="this.$t('key')" -> :prop="$t('key')"
      content = content.replace(
        new RegExp(`(:\\w+)=(['"])this\\.\\$t\\((['"])[^'"]*\\3\\)\\2`, 'g'),
        `$1="$t('${i18nKey}')"`
      );
    }
    
    // 2. 处理JavaScript代码中的字符串（非template部分）
    if (!isInTemplate) {
      // 简单的引号包围的字符串: "中文" 或 '中文'
      content = content.replace(
        new RegExp(`(['"])${escapedText}\\1`, 'g'),
        `this.$t('${i18nKey}')`
      );
    } else {
      // 在Vue文件中，只处理<script>标签内的JavaScript代码
      content = content.replace(
        /<script[^>]*>([\s\S]*?)<\/script>/g,
        (match, scriptContent) => {
          const updatedScript = scriptContent.replace(
            new RegExp(`(['"])${escapedText}\\1`, 'g'),
            `this.$t('${i18nKey}')`
          );
          return match.replace(scriptContent, updatedScript);
        }
      );
    }
    
    // 3. 处理模板字符串（只在JavaScript代码中）
    const processTemplateStrings = (jsContent) => {
      // 处理模板字符串中的纯文本部分: `中文`
      jsContent = jsContent.replace(
        new RegExp('`' + escapedText + '`', 'g'),
        `this.$t('${i18nKey}')`
      );
      
      // 处理模板字符串中嵌套的引号: `"中文"` 或 `'中文'`
      jsContent = jsContent.replace(
        new RegExp('`([\'"])' + escapedText + '\\1`', 'g'),
        `this.$t('${i18nKey}')`
      );
      
      // 处理模板字符串的一部分（需要保持模板字符串语法）
      // 例如: `确认取消"${name}"吗？` -> `${this.$t('confirm_cancel')}${name}吗？`
      jsContent = jsContent.replace(
        new RegExp('`([^`]*?)([\'"])' + escapedText + '\\2([^`]*?)`', 'g'),
        (match, prefix, quote, suffix) => {
          // 如果前缀或后缀包含变量插值，保持模板字符串格式
          if (prefix.includes('${') || suffix.includes('${')) {
            return `\`${prefix}\${this.$t('${i18nKey}')}${suffix}\``;
          } else {
            // 否则可以简化为普通的连接
            return `this.$t('${i18nKey}') + '${suffix}'`;
          }
        }
      );
      
      return jsContent;
    };
    
    if (!isInTemplate) {
      // 对于非Vue文件，直接处理整个内容
      content = processTemplateStrings(content);
    } else {
      // 对于Vue文件，只处理<script>标签内的内容
      content = content.replace(
        /<script[^>]*>([\s\S]*?)<\/script>/g,
        (match, scriptContent) => {
          const updatedScript = processTemplateStrings(scriptContent);
          return match.replace(scriptContent, updatedScript);
        }
      );
    }
    
    return content;
  }

  /**
   * 转义正则表达式特殊字符
   */
  escapeRegex(text) {
    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  }

  /**
   * 生成使用报告
   */
  generateReport() {
    const supportedLanguages = this.getSupportedLanguages();
    
    console.log('\n📊 国际化处理报告:');
    console.log('='.repeat(50));
    console.log(`📁 扫描目录: ${this.srcPath}`);
    console.log(`🔍 扫描文件类型: ${this.fileExtensions.join(', ')}`);
    console.log(`📚 现有中文键值对: ${this.existingChineseKeys.size}`);
    console.log(`🆕 新发现中文文本: ${this.newChineseTexts.size}`);
    console.log(`🌐 支持的语言: ${['zh', ...supportedLanguages].join(', ')}`);
    console.log(`🌐 已生成翻译: ${this.newChineseTexts.size} 个文本 × ${supportedLanguages.length} 种语言`);
    console.log('='.repeat(50));
    
    if (this.newChineseTexts.size > 0 && this.newChineseTexts.size <= 20) {
      console.log('\n📋 新增的国际化键值对示例:');
      let count = 0;
      for (const [chineseText, files] of this.newChineseTexts) {
        if (count >= 10) break; // 只显示前10个示例
        
        const key = this.chineseToKeyMap.get(chineseText);
        console.log(`   ${key}: "${chineseText}"`);
        count++;
      }
      
      if (this.newChineseTexts.size > 10) {
        console.log(`   ... 还有 ${this.newChineseTexts.size - 10} 个键值对`);
      }
    } else if (this.newChineseTexts.size > 0) {
      console.log(`\n📋 已生成 ${this.newChineseTexts.size} 个国际化键值对，翻译已保存到语言包文件中`);
    }
  }

  /**
   * 运行自动化流程
   */
  async run() {
    try {
      // 1. 加载现有语言包
      this.loadExistingLanguagePacks();
      
      // 2. 扫描中文文本
      this.scanChineseTexts();
      
      if (this.newChineseTexts.size === 0) {
        console.log('\n🎉 未发现新的中文文本，国际化已完成！');
        return;
      }
      
      // 3. 生成新的语言包
      const languageEntries = await this.generateLanguagePacks();
      
      // 4. 更新语言包文件
      this.updateLanguageFiles(languageEntries);
      
      // 5. 替换项目文件中的中文
      this.replaceChineseInFiles();
      
      // 6. 生成报告
      this.generateReport();
      
      console.log('\n🎉 自动化国际化处理完成！');
      
    } catch (error) {
      console.error('❌ 自动化国际化处理失败:', error);
      process.exit(1);
    }
  }
}

// 运行脚本
if (require.main === module) {
  const tool = new I18nAutoTool();
  tool.run();
}

module.exports = I18nAutoTool;